/*******************************************************************************
* Copyright (c) 2005, 2006 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.ui.tests.session;
import junit.framework.TestCase;
import org.eclipse.core.resources.IProject;
//import org.eclipse.core.runtime.CoreException;
//import org.eclipse.swt.SWT;
//import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
//import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
//import org.eclipse.ui.ide.IDE;
//import org.eclipse.ui.internal.EditorSite;
//import org.eclipse.ui.internal.EditorStack;
//import org.eclipse.ui.tests.api.SessionEditorPart;
//import org.eclipse.ui.tests.dnd.DragOperations;
//import org.eclipse.ui.tests.dnd.EditorDropTarget;
//import org.eclipse.ui.tests.dnd.ExistingWindowProvider;
import org.eclipse.ui.tests.harness.util.FileUtil;
/**
* Bug 95357 Need a test to ensure editor activation is not broken on startup.
* When eclipse starts, there should be tabs for all of the open editor windows
* but only the <b>active</b> editor window(s) should have been instantiated. A
* bug that crops up occasionally is that all of the editors have been
* instantiated, which impacts performance.
*
* These tests more or less depend on being run in order. The workspace exists
* from method to method.
*
* @since 3.1
*
*/
public class Bug95357Test extends TestCase {
private static final String BUG95357PROJECT = "Bug95357project";
private static final int FILE_MAX = 8;
private IWorkbenchWindow fWin;
private IWorkbenchPage fActivePage;
private IProject fProject;
private IWorkbench fWorkbench;
private String[] itsFilename;
public Bug95357Test(String testName) {
super(testName);
fWorkbench = PlatformUI.getWorkbench();
fProject = null;
}
/**
* @param ext
*/
private void setupFilenames(String ext) {
itsFilename = new String[Bug95357Test.FILE_MAX];
for (int i = 0; i < Bug95357Test.FILE_MAX; ++i) {
itsFilename[i] = "test" + i + ext;
}
}
protected void setUp() throws Exception {
fWin = fWorkbench.getActiveWorkbenchWindow();
fActivePage = fWin.getActivePage();
fProject = FileUtil.createProject(Bug95357Test.BUG95357PROJECT);
}
// /**
// * Multiple editors open - part 1 of 2. This makes sure that there are
// * FILE_MAX editors open, and the files have been created. Then the session
// * stops.
// *
// * @throws PartInitException
// * @throws CoreException
// */
// private void multipleEditors() throws PartInitException, CoreException {
// fActivePage.closeAllEditors(false);
//
// IEditorPart[] part = new IEditorPart[itsFilename.length];
// for (int i = 0; i < itsFilename.length; i++) {
// part[i] = IDE.openEditor(fActivePage, FileUtil.createFile(
// itsFilename[i], fProject), true);
// }
//
// assertTrue(fActivePage.isEditorAreaVisible());
// assertFalse(fActivePage.isPartVisible(part[0]));
// assertTrue(fActivePage.isPartVisible(part[part.length - 1]));
// }
/**
* Multiple editors open - part 2 of 2. We can test the state of eclipse
* after the system has restarted. We expect that the last editor will be
* active and instantiated, but the other editors won't have been
* instantiated.
*/
private void multipleEditorsOpen() {
IEditorReference[] editors = fActivePage.getEditorReferences();
assertEquals(Bug95357Test.FILE_MAX, editors.length);
for (int i = 0; i < editors.length - 1; i++) {
assertNull("Editor " + i + " " + editors[i].getName()
+ " should not be active", editors[i].getEditor(false));
}
assertNotNull(editors[editors.length - 1].getEditor(false));
assertNotNull(editors[0].getEditor(true));
}
// /**
// * Multiple editors in 2 stacks - part 1 of 2. Set up eclipse with FILE_MAX
// * editors open in 2 stacks.
// *
// * @throws PartInitException
// * @throws CoreException
// */
// private void multipleStacks() throws PartInitException, CoreException {
// final String f1 = itsFilename[0];
// final String f2 = itsFilename[1];
// final int startAt = 2;
//
// fActivePage.closeAllEditors(false);
//
// IEditorPart last = IDE.openEditor(fActivePage, FileUtil.createFile(f1,
// fProject), true);
// IEditorPart current = IDE.openEditor(fActivePage, FileUtil.createFile(
// f2, fProject), true);
//
// // create the second editor stack using the second editor
// DragOperations.drag(current, new EditorDropTarget(
// new ExistingWindowProvider(fWin), 0, SWT.BOTTOM), false);
//
// EditorStack firstStack = (EditorStack) ((EditorSite) last
// .getEditorSite()).getPane().getContainer();
// EditorStack secondStack = (EditorStack) ((EditorSite) current
// .getEditorSite()).getPane().getContainer();
//
// for (int i = startAt; i < itsFilename.length; ++i) {
// fActivePage.activate(last);
// last = current;
// current = IDE.openEditor(fActivePage, FileUtil.createFile(
// itsFilename[i], fProject), true);
// }
// assertEquals(Bug95357Test.FILE_MAX / 2, firstStack.getItemCount());
// assertEquals(Bug95357Test.FILE_MAX / 2, secondStack.getItemCount());
// }
/**
* Multiple editors in 2 stacks - part 2 of 2. 2 of the editors should have
* been instantiated. The rest should still be inactive.
*
*/
private void multipleStacksOnStartup() {
IEditorReference lastFile = null;
IEditorReference secondLastFile = null;
IEditorReference[] editors = fActivePage.getEditorReferences();
assertEquals(Bug95357Test.FILE_MAX, editors.length);
for (int i = 0; i < editors.length; i++) {
if (itsFilename[itsFilename.length - 1]
.equals(editors[i].getName())) {
lastFile = editors[i];
} else if (itsFilename[itsFilename.length - 2].equals(editors[i]
.getName())) {
secondLastFile = editors[i];
}
}
assertNotNull(lastFile.getEditor(false));
assertNotNull(secondLastFile.getEditor(false));
for (int i = 0; i < editors.length; ++i) {
if (editors[i] != lastFile && editors[i] != secondLastFile) {
assertNull("For file " + i + " " + editors[i].getName(),
editors[i].getEditor(false));
}
}
}
// /**
// * Test for .txt files and the basic editor. Part 1 of 2
// *
// * @throws Throwable
// */
// public void testMultipleEditors() throws Throwable {
// setupFilenames(".txt");
//
// multipleEditors();
// }
/**
* Test for .txt files and the basic editor. Part 2 of 2
*
* @throws Throwable
*/
public void testMultipleEditorsOpen() throws Throwable {
setupFilenames(".txt");
multipleEditorsOpen();
}
// /**
// * Test multiple stacks with .txt editor. Part 1 of 2
// *
// * @throws Throwable
// */
// public void testMultipleStacks() throws Throwable {
// setupFilenames(".txt");
// multipleStacks();
// }
/**
* Test multiple stacks with .txt editor. Part 2 of 2
*
* @throws Throwable
*/
public void testMultipleStacksOnStartup() throws Throwable {
setupFilenames(".txt");
multipleStacksOnStartup();
}
// /**
// * Test for .session files and the SessionEditorPart editor. Part 1 of 2
// *
// * @throws Throwable
// */
// public void testMultipleEditorsSession() throws Throwable {
// setupFilenames(".session");
// multipleEditors();
// assertEquals(Bug95357Test.FILE_MAX, SessionEditorPart.instantiatedEditors);
//
// }
//
// /**
// * Test for .session files and the SessionEditorPart editor. Part 2 of 2
// *
// * @throws Throwable
// */
// public void testMultipleEditorsOpenSession() throws Throwable {
// setupFilenames(".session");
// multipleEditorsOpen();
// assertEquals(2, SessionEditorPart.instantiatedEditors);
// }
//
// /**
// * Test multiple stacks with .session editor. Part 1 of 2
// *
// * @throws Throwable
// */
// public void testMultipleStacksSession() throws Throwable {
// setupFilenames(".session");
// SessionEditorPart.instantiatedEditors = 0;
// multipleStacks();
// assertEquals(Bug95357Test.FILE_MAX, SessionEditorPart.instantiatedEditors);
//
// }
//
// /**
// * Test multiple stacks with .session editor. Part 2 of 2
// *
// * @throws Throwable
// */
// public void testMultipleStacksOnStartupSession() throws Throwable {
// setupFilenames(".session");
// multipleStacksOnStartup();
// assertEquals(2, SessionEditorPart.instantiatedEditors);
// }
}